#pragma once
#include "Sock.hpp"
#include <functional>
#include <vector>
#include<unistd.h>
#include<pthread.h>
typedef std::function<void(int)> fun_t;
namespace na_Tcpserver
{
    class TcpServer;
    class ServerData
    {
        public:
        ServerData(int servicesock,TcpServer* server)
        :_servicesock(servicesock)
        ,_server(server)
        {

        }
        public:
        int _servicesock;
        TcpServer* _server;

    };

    class TcpServer
    {
    public:
   
        static void* routine(void*args)
        {
            pthread_detach(pthread_self());//线程分离，主线程不用等待子线程
            ServerData* serverdata=(ServerData*)args;
            serverdata->_server->Exute(serverdata->_servicesock);
            close(serverdata->_servicesock);
            


        }
        TcpServer( uint16_t port,std::string ip="0.0.0.0") 
        {
              _listensock=_sock.Socket();
              _sock.Bind(_listensock,port,ip);
             _sock.Listen(_listensock);

        }
        void BindServer(fun_t fun)//给服务器绑定要执行的函数
        {
            _fun.push_back(fun);

        }
        void Exute(int sock)//执行绑定的函数
        {
           for(auto&iter:_fun)
           {
            iter(sock);
           }
        }
        void start()//启动服务器
        {
            int servicesock;
            for(;;)
            {
                uint16_t client_port;
                std::string client_ip;
                servicesock=_sock.Accept(_listensock,&client_port,&client_ip);
                if(servicesock==-1)
                {
                    continue;
                }
                logMessage(NORMAL,"create new link success,%d",servicesock);
                ServerData* serverdata=new ServerData(servicesock,this);
                pthread_t tid;
                pthread_create(&tid,nullptr,routine,(void*)serverdata);
                



            }
        }
        ~TcpServer()
        {
            if(_listensock>=0)
            {
                close(_listensock);
                
            }
        }

    private:
        int _listensock;
        Sock _sock;
        std::vector<fun_t> _fun;
        
    };
}